package com.ruoyi.classroom.course.service.impl;

import com.ruoyi.classroom.course.domain.MyTeacherCourse;
import com.ruoyi.classroom.course.mapper.MyTeacherCourseMapper;
import com.ruoyi.classroom.course.service.IMyTeacherCourseService;
import com.ruoyi.classroom.user.domain.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 我的授课Service业务层处理
 * 
 * @author lgm
 * @date 2024-07-25
 */
@Service
public class MyTeacherCourseServiceImpl implements IMyTeacherCourseService
{
    @Autowired
    private MyTeacherCourseMapper myTeacherCourseMapper;

    /**
     * 查询我的授课
     * 
     * @param id 我的授课主键
     * @return 我的授课
     */
    @Override
    public MyTeacherCourse selectMyTeacherCourseById(Long id)
    {
        return myTeacherCourseMapper.selectMyTeacherCourseById(id);
    }

    /**
     * 查询我的授课列表
     * 
     * @param myTeacherCourse 我的授课
     * @return 我的授课
     */
    /*@Override
    public List<MyTeacherCourse> selectMyTeacherCourseList(MyTeacherCourse myTeacherCourse)
    {
//        获取到所有数据；
        List<MyTeacherCourse> courses = myTeacherCourseMapper.selectMyTeacherCourseList(myTeacherCourse);
        for (MyTeacherCourse cours : courses) {
//        判断，如果term为“第二学期”，years为“2024-2025”，is_used为0的条件下，
            if (cours.getTerm().equals("第二学期")
                    && cours.getYears().equals("2024-2025")
                    && cours.getIsUsed() == 0) {
//        接着：根据满足三个条件的数据库获取的数据，再比较name，name如果相同，了就只返回查询到name的第一条记录；
                if (courses.stream().filter(c -> c.getName().equals(cours.getName())).count() > 1) {
                    courses.remove(cours);
                }
            }
        }
        return courses;
    }*/
    @Override
    public List<MyTeacherCourse> selectMyTeacherCourseList(MyTeacherCourse myTeacherCourse) {
        // 获取到所有数据；
        List<MyTeacherCourse> allCourses = myTeacherCourseMapper.selectMyTeacherCourseList(myTeacherCourse);

        // 使用流式操作一次性筛选出符合条件的课程，并使用LinkedHashMap去重
        Map<String, MyTeacherCourse> filteredMap = allCourses.stream()
                .filter(c -> "第二学期".equals(c.getTerm())
                        && "2024-2025".equals(c.getYears())
                        && c.getIsUsed() == 0)
                .collect(Collectors.toMap(
                        MyTeacherCourse::getName,
                        c -> c,
                        (oldVal, newVal) -> oldVal,
                        LinkedHashMap::new));

        // 将Map转换回List
        return new ArrayList<>(filteredMap.values());
    }
    /**
     * 新增我的授课
     * 
     * @param myTeacherCourse 我的授课
     * @return 结果
     */
    @Override
    public int insertMyTeacherCourse(MyTeacherCourse myTeacherCourse)
    {
        return myTeacherCourseMapper.insertMyTeacherCourse(myTeacherCourse);
    }

    /**
     * 修改我的授课
     * 
     * @param myTeacherCourse 我的授课
     * @return 结果
     */
    @Override
    public int updateMyTeacherCourse(MyTeacherCourse myTeacherCourse)
    {
        return myTeacherCourseMapper.updateMyTeacherCourse(myTeacherCourse);
    }

    /**
     * 批量删除我的授课
     * 
     * @param ids 需要删除的我的授课主键
     * @return 结果
     */
    @Override
    public int deleteMyTeacherCourseByIds(Long[] ids)
    {
        return myTeacherCourseMapper.deleteMyTeacherCourseByIds(ids);
    }

    /**
     * 删除我的授课信息
     * 
     * @param id 我的授课主键
     * @return 结果
     */
    @Override
    public int deleteMyTeacherCourseById(Long id)
    {
        return myTeacherCourseMapper.deleteMyTeacherCourseById(id);
    }

    /**
     * 查询我的课程
     * @param myTeacherCourse 我的授课
     * @return
     */
    @Override
    public List<User> selectStudentCourseList(MyTeacherCourse myTeacherCourse) {
        return myTeacherCourseMapper.selectStudentCourseList(myTeacherCourse);
    }


}
